home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / os2tools / bnklysrc / evtparse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-02-25  |  15.6 KB  |  505 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software <no-Inc>                   */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          No-Cost<no-tm> Software.                       */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*  Copyright (C) 1987, 1988, 1989 by Robert Hartman and Vincent Perriello  */
  11. /*                                                                          */
  12. /*                                                                          */
  13. /*                 This module was written by Bob Hartman                   */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*                     BinkleyTerm Scheduler Routines                       */
  17. /*                                                                          */
  18. /*                                                                          */
  19. /*    For complete  details  of the licensing restrictions, please refer    */
  20. /*    to the License  agreement,  which  is published in its entirety in    */
  21. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.210.    */
  22. /*                                                                          */
  23. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  24. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  25. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  26. /*    NOT HAVE THESE FILES,  YOU SHOULD  IMMEDIATELY CONTACT THE AUTHORS    */
  27. /*    AT THE  ADDRESSES LISTED BELOW.  IN NO EVENT SHOULD YOU PROCEED TO    */
  28. /*    USE   THIS  FILE  WITHOUT  HAVING   ACCEPTED  THE  TERMS  OF   THE    */
  29. /*    BINKLEYTERM  LICENSING AGREEMENT,  OR SUCH OTHER  AGREEMENT AS YOU    */
  30. /*    ARE ABLE TO REACH WITH THE AUTHORS.                                   */
  31. /*                                                                          */
  32. /*                                                                          */
  33. /*    The Authors can be reached at the following addresses:                */
  34. /*                                                                          */
  35. /*    Robert C. Hartman                      Vincent E. Perriello           */
  36. /*    Spark Software                         VEP Software                   */
  37. /*    427-3 Amherst Street                   111 Carroll Street             */
  38. /*    CS2032, Suite 232                      Naugatuck, CT 06770            */
  39. /*    Nashua, NH 03061                                                      */
  40. /*                                                                          */
  41. /*    FidoNet 1:132/101                      FidoNet 1:141/491              */
  42. /*    Data    (603) 888-8179                 Data    (203) 729-7569         */
  43. /*                                                                          */
  44. /*    Please feel free to contact us at any time to share your comments     */
  45. /*    about our software and/or licensing policies.                         */
  46. /*                                                                          */
  47. /*--------------------------------------------------------------------------*/
  48.  
  49. #include <stdio.h>
  50. #include <ctype.h>
  51. #include <sys/types.h>
  52. #include <sys/stat.h>
  53. #include <string.h>
  54. #include <stdlib.h>
  55. #include <process.h>
  56. #include <time.h>
  57.  
  58. #ifdef __TURBOC__
  59. #include "tc_utime.h"
  60. #include <alloc.h>
  61. #include <mem.h>
  62. #else
  63. #include <sys/utime.h>
  64. #include <malloc.h>
  65. #include <memory.h>
  66. #endif
  67.  
  68. #include "com.h"
  69. #include "xfer.h"
  70. #include "zmodem.h"
  71. #include "keybd.h"
  72. #include "sbuf.h"
  73. #include "sched.h"
  74. #include "externs.h"
  75. #include "prototyp.h"
  76.  
  77. static char *start_time (EVENT *, char *);
  78. static char *end_time (EVENT *, char *);
  79. static void write_stats (void);
  80.  
  81.  
  82. /**************************************************************************/
  83. /*** This MUST be exactly 16 total bytes including the terminating null ***/
  84. /*** or the routines read_sched() and write_sched() must be changed!!!! ***/
  85. /**************************************************************************/
  86. static char *BinkSched = "BinkSchedule 02";      /* Version of scheduler   */
  87.  
  88. static char *start_time (e, p)
  89. EVENT *e;
  90. char *p;
  91. {
  92.    int i, j, k, l, n;
  93.  
  94.    if ((n = sscanf (p, "%d:%d,%d,%d", &i, &j, &k, &l)) < 2)
  95.       {
  96.       return NULL;
  97.       }
  98.  
  99.    e->minute = i * 60 + j;
  100.    if ((e->minute < 0) || (e->minute > (24 * 60)))
  101.       {
  102.       return (NULL);
  103.       }
  104.  
  105.    if (n >= 3)
  106.       e->month = (char)k;
  107.    if (n >= 4)
  108.       e->day = (char)l;
  109.  
  110.    p = skip_to_blank (p);
  111.  
  112.    return (p);
  113. }
  114.  
  115. static char *end_time (e, p)
  116. EVENT *e;
  117. char *p;
  118. {
  119.    int i, j, k;
  120.  
  121.    if (sscanf (p, "%d:%d", &i, &j) != 2)
  122.       {
  123.       return NULL;
  124.       }
  125.  
  126.    k = i * 60 + j;
  127.    if ((k > (24 * 60)) || (k < 0))
  128.       {
  129.       return (NULL);
  130.       }
  131.  
  132.    if (k < e->minute)
  133.       {
  134.       printf ("Ending time wraps through midnight - not allowed\n");
  135.       return (NULL);
  136.       }
  137.  
  138.    e->length = k - e->minute;
  139.  
  140.    p = skip_to_blank (p);
  141.  
  142.    return (p);
  143. }
  144.  
  145. int parse_event (e_line)
  146. char *e_line;
  147. {
  148.    int i, j, j1, j2;
  149.    char *p, *p1;
  150.    EVENT *e;
  151.  
  152.    /* If we already have a schedule, then forget it */
  153.    if (got_sched)
  154.       return (0);
  155.  
  156.    /* Skip blanks to get to the days field */
  157.    p = skip_blanks (e_line);
  158.  
  159.    /* Parse the days field */
  160.    e = (EVENT *) calloc (sizeof (EVENT), 1);
  161.    e->days = 0;
  162.    e->wait_time = 120;
  163.    while ((*p) && (!isspace (*p)))
  164.       {
  165.       switch (toupper (*p))
  166.          {
  167.          case 'S':                              /* Sunday or Saturday */
  168.             if (!strnicmp (p, "sun", 3))
  169.                {
  170.                e->days |= DAY_SUNDAY;
  171.                }
  172.             else if (!strnicmp (p, "sat", 3))
  173.                {
  174.                e->days |= DAY_SATURDAY;
  175.                }
  176.             else /* Error condition */ 
  177.                {
  178.                goto err;
  179.                }
  180.             p += 3;
  181.             break;
  182.  
  183.          case 'M':                              /* Monday */
  184.             if (!strnicmp (p, "mon", 3))
  185.                {
  186.                e->days |= DAY_MONDAY;
  187.                }
  188.             else /* Error condition */ 
  189.                {
  190.                goto err;
  191.                }
  192.             p += 3;
  193.             break;
  194.  
  195.          case 'T':                              /* Tuesday or Thursday */
  196.             if (!strnicmp (p, "tue", 3))
  197.                {
  198.                e->days |= DAY_TUESDAY;
  199.                }
  200.             else if (!strnicmp (p, "thu", 3))
  201.                {
  202.                e->days |= DAY_THURSDAY;
  203.                }
  204.             else /* Error condition */ 
  205.                {
  206.                goto err;
  207.                }
  208.             p += 3;
  209.             break;
  210.  
  211.          case 'W':                              /* Wednesday, Week or
  212.                                                   * Weekend */
  213.             if (!strnicmp (p, "wed", 3))
  214.                {
  215.                e->days |= DAY_WEDNESDAY;
  216.                p += 3;
  217.                }
  218.             else if (!strnicmp (p, "week", 4))
  219.                {
  220.                e->days |= DAY_WEEK;
  221.                p += 4;
  222.                }
  223.             else if (!strnicmp (p, "wkend", 5))
  224.                {
  225.                e->days |= DAY_WKEND;
  226.                p += 5;
  227.                }
  228.             else /* Error condition */ 
  229.                {
  230.                goto err;
  231.                }
  232.             break;
  233.  
  234.          case 'F':                              /* Friday */
  235.             if (!strnicmp (p, "fri", 3))
  236.                {
  237.                e->days |= DAY_FRIDAY;
  238.                }
  239.             else /* Error condition */ 
  240.                {
  241.                goto err;
  242.                }
  243.             p += 3;
  244.             break;
  245.  
  246.          case 'A':                              /* All */
  247.             if (!strnicmp (p, "all", 3))
  248.                {
  249.                e->days |= (DAY_WEEK | DAY_WKEND);
  250.                }
  251.             else /* Error condition */ 
  252.                {
  253.                goto err;
  254.                }
  255.             p += 3;
  256.             break;
  257.  
  258.          default:                               /* Error condition */
  259.             goto err;
  260.          }
  261.  
  262.       if (*p == '|')
  263.          ++p;
  264.       }
  265.  
  266.    /* Did we get something valid? */
  267.    if (e->days == 0)
  268.       {
  269.       goto err;
  270.       }
  271.  
  272.    /* Skip blanks to get to the start-time field */
  273.    p = skip_blanks (p);
  274.  
  275.    /* Parse the start-time field */
  276.    if ((p = start_time (e, p)) == NULL)
  277.       {
  278.       printf ("'%s' has an invalid START-TIME\n", e_line);
  279.       free (e);
  280.       return (1);
  281.       }
  282.  
  283.    /* Give each event a default of 60 minutes */
  284.    e->length = 60;
  285.  
  286.    /* Give each event a local cost of 0 */
  287.    e->node_cost = 0;
  288.  
  289.    /* Give each event a default of T=3,10000 */
  290.    e->with_connect = 3;
  291.    e->no_connect = 10000;
  292.  
  293.    /* While there are still things on the line */
  294.    while (*p)
  295.       {
  296.       /* Skip blanks to get to the next field */
  297.       p = skip_blanks (p);
  298.  
  299.       /* switch to find what thing is being parsed */
  300.       switch (tolower (*p))
  301.          {
  302.          case '\0':                             /* No more stuff */
  303.             break;
  304.  
  305.          case '0':                              /* Digits must be an ending
  306.                                                   * time */
  307.          case '1':
  308.          case '2':
  309.          case '3':
  310.          case '4':
  311.          case '5':
  312.          case '6':
  313.          case '7':
  314.          case '8':
  315.          case '9':
  316.             /* Parse ending time */
  317.             if ((p = end_time (e, p)) == NULL)
  318.                {
  319.                printf ("'%s' has an invalid END-TIME\n", e_line);
  320.                free (e);
  321.                return (1);
  322.                }
  323.             break;
  324.  
  325.          case ';':                              /* Comment */
  326.          case '%':
  327.             *p = '\0';
  328.             break;
  329.  
  330.          case '"':                              /* Extra chars to append to
  331.                                                   * packer strings */
  332.             ++p;
  333.             p1 = e->cmd;
  334.             *p1++ = ' ';
  335.             while (*p != '"')
  336.                *p1++ = *p++;
  337.             *p1 = '\0';
  338.             ++p;
  339.             break;
  340.  
  341.          case 'a':                              /* Average wait */
  342.             ++p;
  343.             if (*p == '=')
  344.                {
  345.                ++p;
  346.                if (isdigit (*p))
  347.                   {
  348.                   i = atoi (p);
  349.                   if ((i > 1800) || (i < 0))
  350.                      {
  351.                      printf ("'%s' has bad AvgWait (higher than max of 1800 or less than min of 0)\n", e_line);
  352.                      free (e);
  353.                      return (1);
  354.                      }
  355.                   e->wait_time = i;
  356.                   p = skip_to_blank (p);
  357.                   break;
  358.                   }
  359.                }
  360.             printf ("'%s' has a bad AvgWait code\n", e_line);
  361.             free (e);
  362.             return (1);
  363.  
  364.          case 'b':                              /* BBS type event */
  365.             p = skip_to_blank (p);
  366.             e->behavior |= MAT_BBS;
  367.             break;
  368.  
  369.          case 'c':                              /* #CM event */
  370.             p = skip_to_blank (p);
  371.             e->behavior |= MAT_CM;
  372.             break;
  373.  
  374.          case 'd':                              /* Dynamic event */
  375.             p = skip_to_blank (p);
  376.             e->behavior |= MAT_DYNAM;
  377.             break;
  378.  
  379.          case 'e':                              /* An errorlevel exit */
  380.             ++p;
  381.             if (isdigit (*p))
  382.                {
  383.                i = *p - '0';
  384.                ++p;
  385.                if ((*p == '=') && (i <= 5) && (i > 0))
  386.                   {
  387.                   ++p;
  388.                   if (isdigit (*p))
  389.                      {
  390.                      j = atoi (p);
  391.                      e->errlevel[i - 1] = j;
  392.                      p = skip_to_blank (p);
  393.                      break;
  394.                      }
  395.                   }
  396.                }
  397.             printf ("'%s' has a bad Errorlevel code\n", e_line);
  398.             free (e);
  399.             return (1);
  400.  
  401.          case 'f':                              /* Forced event */
  402.             p = skip_to_blank (p);
  403.             e->behavior |= MAT_FORCED;
  404.             break;
  405.  
  406.          case 'k':                              /* no #CM event */
  407.             p = skip_to_blank (p);
  408.             e->behavior |= MAT_NOCM;
  409.             break;
  410.  
  411.          case 'l':                              /* Local only mail */
  412.             ++p;
  413.             e->node_cost = 0;
  414.             if (*p == '=')
  415.                {
  416.                ++p;
  417.                if (isdigit (*p))
  418.                   {
  419.                   e->node_cost = atoi (p);
  420.                   }
  421.                }
  422.             else if (*p == '>')
  423.                {
  424.                ++p;
  425.                if (isdigit (*p))
  426.                   {
  427.                   e->node_cost = -atoi (p) - 1;
  428.                   }
  429.                }
  430.             else if (*p == '<')
  431.                {
  432.                ++p;
  433.                if (isdigit (*p))
  434.                   {
  435.                   e->node_cost = atoi (p) - 1;
  436.                   }
  437.                }
  438.             p = skip_to_blank (p);
  439.             e->behavior |= MAT_LOCAL;
  440.             break;
  441.  
  442.          case 'm':                              /* Mailable 24 hours */
  443.             p = skip_to_blank (p);
  444.             e->behavior |= MAT_NOMAIL24;
  445.             break;
  446.  
  447.          case 'n':                              /* No requests */
  448.             p = skip_to_blank (p);
  449.             e->behavior |= MAT_NOREQ;
  450.             break;
  451.  
  452.          case 'r':                              /* Receive only */
  453.             p = skip_to_blank (p);
  454.             e->behavior |= MAT_NOOUT;
  455.             break;
  456.  
  457.          case 's':                              /* Send only */
  458.             p = skip_to_blank (p);
  459.             e->behavior |= MAT_OUTONLY;
  460.             break;
  461.  
  462.          case 't':                              /* Tries */
  463.             ++p;
  464.             if (sscanf (p, "=%d,%d", &j1, &j2) != 2)
  465.                {
  466.                printf ("'%s' has a bad number of Tries\n", e_line);
  467.                return (1);
  468.                }
  469.             else
  470.                {
  471.                if ((j1 > 8) || (j1 < 1))
  472.                   {
  473.                   printf ("'%s' has a bad number of Tries\n", e_line);
  474.                   return (1);
  475.                   }
  476.                e->with_connect = j1;
  477.                e->no_connect = j2;
  478.                }
  479.             p = skip_to_blank (p);
  480.             break;
  481.  
  482.          case 'x':                              /* No outbound requests here */
  483.             p = skip_to_blank (p);
  484.             e->behavior |= MAT_NOOUTREQ;
  485.             break;
  486.  
  487.          default:                               /* Error condition */
  488.             printf ("'%s' has something indecipherable\n", e_line);
  489.             free (e);
  490.             return (1);
  491.          }
  492.       }
  493.  
  494.    /* Save it in the array  of pointers */
  495.    e_ptrs[num_events++] = e;
  496.  
  497.    /* Return that everything is cool */
  498.    return (0);
  499.  
  500. err:
  501.    printf ("'%s' has an invalid DAY field\n", e_line);
  502.    free (e);
  503.    return (1);
  504. }
  505.